/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package gestores;

//import baseDatosViejo.AnimalDAO;
//import baseDatosViejo.CamaraDAO;
//import baseDatosViejo.CategoriaDAO;
//import baseDatosViejo.EstadoJaulaDAO;
//import baseDatosViejo.TipoCamaraDAO;
//import baseDatosViejo.TipoEventoDAO;
//import entidades.Animal2;
import baseDatos.*;
import entidades.Animal;
import conexion.GestorConexion;
import entidades.Bateria;
import entidades.Camara;
import entidades.Categoria;
import entidades.DetalleEnfermedad;
import entidades.DetalleFamilia;
import entidades.Enfermedad;
import entidades.Familia;
import entidades.Historial;
import entidades.Jaula;
import entidades.Sexo;
import entidades.TipoEvento;
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.DefaultListModel;
import oracle.sql.DATE;
import visuales.AbmAnimal2;
import visuales.Historial_evento;

/**
 *
 * @author Facundo
 */
public class GestorProduccion extends GestorConexion {

//    public GestorProduccion(){
//
//    }
//
//    /*
//     * PRIMERA PARTE!!!!!
//     * En esta parte se declaran los metodos para insertar o actualizar objetos en la base
//     */
//    /*
//     * Metodo para insertar un nuevo animal en la base de datos
//     */
//    public boolean insertarAnimal(Animal ani){
//        boolean ret = false;
//        this.conectar();
//        ret = new AnimalDAO().put(ani);
//        this.desconectar();
//        return ret;
//
//    }
//    /*
//     * Metodo para modificar un animal existente
//     */
//    public boolean updateAnimal(Animal ani){
//        boolean ret = false;
//        this.conectar();
//        ret = new AnimalDAO().update(ani);
//        this.desconectar();
//        return ret;
//    }
//    /*
//     * Metodo para modificar una jaula existente. Se le modifica el estado de la jaula
//     */
//    public boolean updateJaula(Camara cam, EstadoJaula estado){
//        boolean ret = false;
//        this.conectar();
//         /*
//                 * Aka, se declara un iterator para el recorrer un array de baterias, perteneciente a una
//                 * determinada camara. Luego se declara otro iterator para recorrer un array de jaulas
//                 * pertenecientes a una determinada bateria.                 *
//                 */
//                Iterator iter = cam.getBateria().iterator();
//                Bateria bat = (Bateria) iter.next();
//                Iterator iter2 = bat.getJaula().iterator();
//                Jaula jau = (Jaula) iter2.next();
//                /*
//                 * Luego de obtenida la jaula y la bateria, ya que la camara ya la teniamos a trvez del animal,
//                 * debemos obtener el codigo de cada una de ellas, para poder insertar el codigo de la jaula,
//                 * en la tabla animal.
//                 */
//                int codigoTipoCamara = new TipoCamaraDAO().devolverCodigoCamara(cam.getTipo_camara().getNombre());
//                int codigoCamara = new CamaraDAO().getCodigoCamara(cam.getNombre(), codigoTipoCamara);
//                int codigoBateria = new BateriaDAO().devolverCodigoBateria(bat.getNombre(),codigoCamara);
//                int codigoJaula = new JaulaDAO().devolverCodigoJaula(jau.getNombre(), codigoBateria);
//        int codigoEstado = new EstadoJaulaDAO().devolverCodigoEstadoJaula(estado);
//        ret = new JaulaDAO().update(jau, codigoJaula, codigoEstado);
//        this.desconectar();
//        return ret;
//    }
//    /*
//     * FIN PRIMERA PARTE!!!!
//     */
////*****************************************************************************************************\\
//
//    /*
//     * SEGUNDA PARTE!!!!!
//     * En esta parte se declaran los metodos para obtener array de objetos, dependiendo o no
//     * de los parametros de entradas..
//     */
//
//    /*
//     * Metodo que devuelve todas las causas de muertes
//     */
//    public ArrayList allCausasMuertes(){
//        this.conectar();
//        ArrayList lista = new CausaMuerteDAO(this.getCon()).getCausaMuertes();
//        this.desconectar();
//        return lista;
//    }
//    /*
//     * Metodo que devuelve todos los tipos de camaras
//     */
//    public ArrayList allTipoCamaras(){
//        this.conectar();
//        ArrayList lista = new TipoCamaraDAO(this.getCon()).getTipoCamaras();
//        this.desconectar();
//        return lista;
//    }
//    /*
//     * Metodo que devuelve todas las categorias de camaras
//     */
//    public ArrayList allCategorias(){
//        this.conectar();
//        ArrayList lista = new CategoriaDAO(this.getCon()).getCategorias();
//        this.desconectar();
//        return lista;
//    }
//    /*
//     * Trae todo los animales de la base
//     */
//    public ArrayList allAnimales(){
//        this.conectar();
//        ArrayList lista=new AnimalDAO(this.getCon()).getAnimales();
//        this.desconectar();
//        return lista;
//    }
//     /*
//     * Trae todo las baterias de la base
//     */
//    public ArrayList allBaterias(){
//        this.conectar();
//        ArrayList lista = new BateriaDAO(this.getCon()).getBaterias();
//        this.desconectar();
//        return lista;
//    }
//     /*
//      * Trae todo los animales de la base, disponibles para destetar.
//      * debe calcular los animales que tienen fechaDestete mayor o igual a la fecha
//      * que viene por parametro
//      */
//    public ArrayList allAnimalesDestete(Date fecha){
//        this.conectar();
//        ArrayList lista=new AnimalDAO(this.getCon()).animalesDestetar(fecha);
//        this.desconectar();
//        return lista;
//    }
//    /*
//     * Metodo que devuelve un array con camaras de acuerdo al tipo, con sus respetivas baterias y sus respetivas
//     * jaulas con un determinado estado.
//     * Parametros de entrada, tipo de camara y estado de la jaula     *
//     */
//    public ArrayList allCamaraXTipoBateriaJaulaXEstado(int tipoCamara, int estadoJaula){
//        this.conectar();
//        ArrayList camaras = new CamaraDAO(this.getCon()).allCamarasBateriaJaula(tipoCamara,estadoJaula);
//        this.desconectar();
//        return camaras;
//    }
//    /*
//     * Trae todo las jaulas de la base, que pertenescan a una determinada bateria
//     */
//    public ArrayList allJaulaDeBateria(int codigoBateria, int codigoestado){
//        this.conectar();
//        ArrayList lista = new JaulaDAO(this.getCon()).getJaulaBteriaEstado(codigoestado, codigoBateria);
//        this.desconectar();
//        return lista;
//    }
//     /*
//     * Trae todas las baterias de la base, que pertenescan a una determinada camara
//     */
//    public ArrayList allBateriasDeCamara(int codigoCamara){
//        this.conectar();
//        ArrayList lista = new BateriaDAO(this.getCon()).getBaterias(codigoCamara);
//        this.desconectar();
//        return lista;
//    }
//    /*
//     * FIN SEGUNDA PARTE!!!!
//     */
////*****************************************************************************************************\\
//
//
//
//    /*
//     * TERCERA PARTE!!!!!
//     * En esta parte se declaran lso metodos que devuelven un objeto en particular de acuerdo
//     * a los parametros de entrada
//     */
//    /*
//     * Metodo que devuelve un objeto Jaula de acuerdo a la bateria que pertenece y su nombre
//     */
//    public Jaula getJaula(int codigoBateria, String nombre){
//        Jaula jau = null;
//        this.conectar();
//        jau = new JaulaDAO(this.getCon()).getJaula(codigoBateria, nombre);
//        this.desconectar();
//        return jau;
//    }
//    /*
//     * Metodo que devuelve un objeto Bateria de acuerdo a la camara y su nombre
//     */
//    public Bateria getBateria(int codigoCamara, String nombre){
//        Bateria bat = null;
//        this.conectar();
//        bat = new BateriaDAO(this.getCon()).getBateria(codigoCamara, nombre);
//        this.desconectar();
//        return bat;
//    }
//    /*
//     * Metodo que devuelve un objeto Bateria de acuerdo a la camara y su nombre
//     */
//    public Camara getCamara(int codigoTipoCamara, String nombre){
//        Camara cam = null;
//        this.conectar();
//        cam = new CamaraDAO(this.getCon()).getCamara(codigoTipoCamara, nombre);
//        this.desconectar();
//        return cam;
//    }
//    /*
//     * Metodo que devuelve el ultimo gazapo registrado en la base de datos.
//     * Retorna un objeto animal.
//     */
//    public Animal getUltimoNacimiento(){
//        this.conectar();
//        Animal ani = new AnimalDAO(this.getCon()).getUltimoAnimal();
//        return ani;
//    }
//    /*
//     * metodo que devuelve un animal, se pasa como parametro el nombre del mismo. Retorna un
//     * objeto animal
//     */
//      public Animal getAnimal(String nombre){
//        this.conectar();
//        Animal ani =new AnimalDAO(this.getCon()).getAnimal(nombre);
//        this.desconectar();
//        return ani;
//    }
//     /*
//      * Metodo que devuelve un objeto sexo, se pasa como parametro el nombre del mismo. Retorna un
//      * objeto Sexo.
//      */
//     public Sexo getSexo(char nombre){
//         this.conectar();
//         Sexo sex = new SexoDAO(this.getCon()).getSexo(nombre);
//         this.desconectar();
//         return sex;
//     }
//     /*
//      * Metodo que devuelve un objeto , se pasa como parametro el nombre del mismo. Retorna un
//      * objeto EstadoJaula.
//      */
//     public EstadoJaula getEstadoJaula(int codigo){
//         this.conectar();
//         EstadoJaula est = new EstadoJaulaDAO(this.getCon()).getEstadoJaula(codigo);
//         this.desconectar();
//         return est;
//     }
//     /*
//      * Metodo que devuelve un objeto , se pasa como parametro el nombre del mismo. Retorna un
//      * objeto TipoCamara.
//      */
//     public TipoCamara getTipoCamara(int codigo){
//         this.conectar();
//         TipoCamara tipo = new TipoCamaraDAO(this.getCon()).getTipoCamara(codigo);
//         this.desconectar();
//         return tipo;
//     }
//
//     /*
//      * Metodo que devuelve un objeto , se pasa como parametro el nombre del mismo. Retorna un
//      * objeto TipoCamara.
//      */
//     public TipoCamara getTipoCamara(String nombre){
//         this.conectar();
//         TipoCamara tipo = new TipoCamaraDAO(this.getCon()).getTipoCamara(nombre);
//         this.desconectar();
//         return tipo;
//     }
//
//     /*
//      * Metodo que devuelve un objeto , se pasa como parametro el nombre del mismo. Retorna un
//      * objeto Camara.
//      */
//     public Camara getCamara(int codigoCamara){
//         this.conectar();
//         Camara cam = new CamaraDAO(this.getCon()).getCamara(codigoCamara);
//         this.desconectar();
//         return cam;
//     }
//     /*
//      * Metodo que devuelve un objeto bateria , se pasa como parametro el nombre del mismo. Retorna un
//      * objeto Bateria.
//      */
//     public Bateria getBateria(int codigo){
//         this.conectar();
//         Bateria bat = new BateriaDAO(this.getCon()).getBateria(codigo);
//         this.desconectar();
//         return bat;
//     }
//     /*
//      * Metodo que devuelve un objeto , se pasa como parametro el nombre del mismo. Retorna un
//      * objeto Jaula.
//      */
//     public Jaula getJaula(int codigo){
//         this.conectar();
//         Jaula jau = new JaulaDAO(this.getCon()).getJaula(codigo);
//         this.desconectar();
//         return jau;
//     }
//     /*
//      * Metodo que devuelve un animal padre, de acuerdo al nombre de la madre pasada por
//      * parametro
//      */
//     public Animal getPadre(String nombreMadre){
//         Animal ani = null;
//         this.conectar();
//         ani = new FamiliaDAO(this.getCon()).devolverPadre(nombreMadre);
//         this.desconectar();
//         return ani;
//     }
//
//     /*
//     * FIN TERCERA PARTE!!!!
//     */
////*****************************************************************************************************\\
//
//
//
//     /*
//      * CUARTA PARTE!!!!!
//      * En esta parte se declaran los metodos de prueba que tienen o no que ver con la base PampaChin
//      * No prestarle atencion!
//      */
//     /*
//      * Metodo de prueba para el temma del nombre del animal. Este metodo se debe aplicar en los
//      * JFrame, no aca!
//      *
//      */
//     public void metodoNombre(){
//         Animal ani = this.getUltimoNacimiento();
//         String nombre = ani.getNombre();
//         System.out.println(nombre);
//         String numeroNombre = nombre.substring(3);
//         String letraAñoNombre = nombre.substring(2, 3);
//         System.out.println(numeroNombre);
//         System.out.println(letraAñoNombre);
//
//
////            int valor = Integer.parseInt(subnombre);
////            System.out.println(valor);
////            valor++;
////            System.out.println(valor);
////            String nuevoNombre = nombre.substring(0, 3);
////            System.out.println(nuevoNombre+valor);
//
//
//     }
//    /*
//     * Metodo que muestra una letra para un determinado año
//     */
//     public void traerLetra(int año){
//         this.conectar();
//         AnimalDAO ani = new AnimalDAO(this.getCon());
//         ani.traerLetra(año);
//         this.desconectar();
//     }
//    /*
//     * Metodo que devuelve el codigo de TpoCamara de acuerdo a su nombre
//     */
//    public int metodoPruebaTipoCmanara(String nombre){
//        int cod=0;
//        this.conectar();
//        cod =new TipoCamaraDAO(this.getCon()).devolverCodigoCamara(nombre);
//        this.desconectar();
//        return cod;
//    }
//    /*
//     * Metodo de prueba para insetar un tipo de evento
//     */
//    public boolean metodoInsertaTipoEvento(TipoEvento tipo){
//        this.conectar();
//        boolean ret = false;
//        ret = new TipoEventoDAO(this.getCon()).put(tipo);
//        return ret;
//    }
    /*
     * Metodo de prueba, que trae un animal pero de otra base..
     */
//     public Animal2 getAnimal2(String nombre){
//        this.conectar();
//        Animal2 ani =new AnimalDAO(this.getCon()).getAnimal2(nombre);
//        this.desconectar();
//        return ani;
//    }
//
//
//    /*
//     * FIN CUARTA PARTE!!!!
//     */
//*****************************************************************************************************\\

    /*
     * To change this template, choose Tools | Templates
     * and open the template in the editor.
     */
//
///**
// *
// * @author Franco
// */
//public class GestorProduccion {
    private Animal animal;
    private Camara camara;
    private Jaula jaula;
    private String observaciones;
    private DefaultListModel res_animalesPeletear;
    private TipoEvento e_ralgro;
    private TipoEvento e_asignado_familia;
    private TipoEvento e_peleteo;
    private int codigo_bateria;
    private Familia familia;
    private ArrayList res_animalesFamilia;
    private Enfermedad enfermedad;

    public GestorProduccion() {
        super();
        this.codigo_bateria = -1;
    }

    /**
     *
     * Este metodo lo que hace es conectarse a la base y traer todos los animales que estan en condiciones de ser
     * destetados. Se pasa como parametro la fecha del dia de hoy tomado desde el sistema.
     *
     */
    public ArrayList<Animal> buscarAnimalesParaDestetar() {
        this.conectar();
        System.out.println("Buscando animales a destetar...");
        ArrayList paraDestete = new AnimalDAO(this.getCon()).animalesDestetar(this.tomarFechaSistema());
        if (paraDestete == null || paraDestete.isEmpty() == true) {
            System.out.println("No hay animales a destetar o se ha detectato un error en la busqueda de datos...");
            return null;
        } else {
            System.out.println("Existen animales para destetar. Hay una cantidad de " + paraDestete.size() + " gazapos.");
        }
        this.desconectar();
        return paraDestete;
    }

    private DATE tomarFechaHoy() {
        return this.tomarFechaSistema();
//        java.util.Date f = new java.util.Date();
//        return new Date(f.getYear(), f.getMonth(), f.getDay());
    }

    public void setAnimalSeleccionado(Animal animal) {
        this.animal = animal;
    }

    public Animal getAnimalSeleccionado() {
        return animal;
    }

    public void sexoSeleccionado(Sexo sexo) {
        this.animal.setSexo(sexo);
    }

    public void categoriaSeleccionado(Categoria categoria) {
        this.animal.setCategoria(categoria);
    }

    public ArrayList buscarUbicacionDisponible() {
//        TipoCamara tipoCamara = tpDao.tipo("Maduracion");
//
//        //aca tengo que traer la camara segun el tipo de camara que tengo arriba
//        //ahora traigo los jaulas que tienen como estado el estado seleccionado mas arriba
//        //asi voy a obtener la camara que necesito...
//        Bateria bat;
//
//        //aca me trae un array de de array de batarias
//        ArrayList listaBaterias = new ArrayList();
//        ArrayList listaJaulas;
//
//
//        EstadoJaula estJaula = new EstadoJaula();
//        estJaula.setNombre("Disponible");
//
//
//        Camara c = new Camara();
//
//        Jaula jaula;
//
//        for (int i = 0; i < 3; i++) {
//            bat = new Bateria();
//            bat.setDescripcion("descripcion bateria" + i);
//            bat.setNombre("bateria: " + i);
//            listaJaulas = new ArrayList();
//            for (int j = 0; j < 3; j++) {
//                jaula = new Jaula();
//                jaula.setNombre("Jaula: " + i);
////                jaula.setEstado(ejDao.estadoJaula("Disponible"));
//                listaJaulas.add(jaula);
//            }
//            listaBaterias.add(bat);
//        }
//
//
//        return listaBaterias;

        this.conectar();
//        System.out.println("Buscando ubicaciones disponibles...");
////        int tipoCamara = tpDao.devolverCodigoCamara("MADURACION");
////        int estadoJaula = ejDao.devolverCodigoEstadoJaula("DISPONIBLE");
////        ArrayList res = cDao.allCamarasBateriaJaula(tipoCamara, estadoJaula);
//        int tipoCamara = new TipoCamaraDAO(this.getCon()).devolverCodigoCamara("MADURACION");
//        int estadoJaula = new EstadoJaulaDAO(this.getCon()).devolverCodigoEstadoJaula("LIBRE");
//        ArrayList res= new JaulaDAO(this.getCon()).getJaulasMaduracionLibre();
////        ArrayList res = new CamaraDAO(this.getCon()).allCamarasBateriaJaula(tipoCamara, estadoJaula);
        ArrayList res = new CamaraDAO(this.getCon()).allCamaraLibreMaduracion();
        this.desconectar();
//        Iterator iter_res=res.iterator();
//        while (iter_res.hasNext()) {
//            System.out.println("asdasdasd "+iter_res.next());
//        }
        return res;
    }

    public String confirmacionAceptada(boolean res, int flap) {
        String msg = "FAIL";
        System.out.println("Tomando confirmacion de acciones...");
        boolean res_evento = false;
        if (res && flap != -1) {
//            if (this.actualizarDatosAnimal(solapa)) {
//                mensaje = "OK";
//            }
            switch (flap) {
                case TipoEvento.DESTETE:
                    System.out.println("Se procede a realizar la actualizacion de los datos por destete:");
                    res_evento = this.actualizarDatosAnimal();
                    break;
                case TipoEvento.RALGRO:
                    res_evento = this.aplicarRalgro();
                    break;
                case TipoEvento.PELETEO:
                    res_evento = this.aplicarPeleteo();
                    break;
                case TipoEvento.ASIGNAR:
                    res_evento = this.asignarFamilia();
                    break;
                case TipoEvento.ENFERMEDAD:
                    res_evento = this.asignarEnfermedad();
                    break;
                case TipoEvento.CURACION:
                    res_evento = true;
                    break;
            }
            System.out.println("Generando historial...");
            boolean res_historic = this.generarHistorial(flap);
            if (res_historic) {
                System.out.println("Historial generado correctamente.");
            } else {
                System.out.println("Problemas al generar el historial.");
            }
            if (res_evento & res_historic) {
                msg = "OK";
            }
        }
        return msg;
    }

    public boolean aplicarRalgro() {
        return true;
    }

    public boolean actualizarDatosAnimal() {
        System.out.println("Actualizando datos del animal...");
        this.conectar();
        boolean res = false;
//        if (flap == AbmAnimal2.FLAP_DESTETE) {
//            if (animal == null) {
//                System.out.println("vacio");
//            } else {
//                System.out.println("*" + animal);
//            }
        res = new AnimalDAO(this.getCon()).updateDestete(this.animal);
        if (res) {
            System.out.println("Datos actualizados correctamente...");
//            }
        }
        this.desconectar();
        return res;
    }

    public boolean generarHistorial(int flap) {
        Historial hist = new Historial();
        hist.setFecha(this.tomarFechaSistema());
        switch (flap) {
            case TipoEvento.DESTETE:
                TipoEvento te = this.esDestete();
                if (te != null) {
                    System.out.println("Se setea el tipo de evento al historial creado.");
                    hist.setTipo_evento(te);
                    hist.setAnimal(this.getAnimalSeleccionado());
                    hist.setDescripcion("Nueva ubicacion: " + hist.getAnimal().getUbicacionActual());
                } else {
                    System.out.println("No es posible encontrar el tipo de evento, no se puede grabar el historial.");
                    hist = null;
                }
                break;
            case TipoEvento.RALGRO:
                hist.setAnimal(this.animal);
                hist.setTipo_evento(this.esRalgro());
                hist.setDescripcion(this.getObservacionesVarias());
                break;
            case TipoEvento.ENFERMEDAD:
                Animal res = this.getAnimalSeleccionado();
                System.out.println("Registrando enfermedad para el animal: " + res.getNombre());
                hist.setTipo_evento(this.esEnfermedad());
                hist.setAnimal(res);
                hist.setDescripcion(this.getObservacionesVarias());
                DetalleEnfermedad detEnfermedad = new DetalleEnfermedad();
                detEnfermedad.setEnfermedad(this.getEnfermedadAnimal());
                detEnfermedad.setFecha_deteccion(this.tomarFechaSistema());
                detEnfermedad.setObservaciones(this.getObservacionesVarias());
                hist.setDetalle_enfermedad(detEnfermedad);
                break;
            case TipoEvento.CURACION:
                hist.setAnimal(this.getAnimalSeleccionado());
                hist.setDescripcion(this.getObservacionesVarias());
                hist.setTipo_evento(this.esCuracion());
                break;
        }
        this.conectar();
        boolean res = false, res_updateAnimal = false, res_insertFamilia = false, res_insertDetalleFamilia = false;
        if (this.getCon() == null || hist == null) {
            System.out.println("Ah ocurrido un  problema con la conexion o no se ha podido crear el historial.");
            res = false;
        } else {
            switch (flap) {
                case TipoEvento.PELETEO:
                    if (this.getListaPeletear().isEmpty() == false) {
                        System.out.println("Existen animales a peletear.");
                        Object[] res_peleteo = this.getListaPeletear().toArray();
                        Animal res_animal_peleteo = null;
                        for (int i = 0; i < res_peleteo.length; i++) {
                            res_animal_peleteo = (Animal) res_peleteo[i];
                            hist.setAnimal(res_animal_peleteo);
                            hist.setDescripcion("Se peleteo el animal " + hist.getAnimal().getNombre());
                            hist.setTipo_evento(this.esPeleteo());
                            res = new HistorialDAO(this.getCon()).put(hist);
                            if (!res) {
                                System.out.println("Error al procesar el animal: " + hist.getAnimal().datosAnimal());
                                break;
                            }
                        }
                    } else {
                        System.out.println("Lista vacia de animales a peletear.");
                    }
                    break;
                case TipoEvento.ASIGNAR:
                    Familia res_getFamilia = this.getFamilia();
                    if (res_getFamilia != null) {
                        System.out.println("Existe una nueva familia.");
                        boolean res_familiaDetalle = new FamiliaDAO(this.getCon()).put(res_getFamilia);
                        if (res_familiaDetalle) {
                            Iterator iter_detalleFamilia = this.getFamilia().getDetalle().iterator();
                            Animal res_animalFamilia = null;
                            DetalleFamilia detFamilia = null;
                            hist.setAnimal(res_getFamilia.getPadre());
                            if (this.insertarDetalleFamilia(hist) == true) {
                                while (iter_detalleFamilia.hasNext()) {
                                    detFamilia = (DetalleFamilia) iter_detalleFamilia.next();
                                    res_animalFamilia = detFamilia.getHembra();
                                    hist.setAnimal(res_animalFamilia);
                                    res = this.insertarDetalleFamilia(hist);
                                    System.out.println("res_insertDetalleFamilia: " + res);
                                    if (res == false) {
                                        System.out.println("Error al procesar el animal: " + hist.getAnimal().getNombre());
                                        break;
                                    }
                                }
                            }
                        }
                    } else {
                        System.out.println("Lista vacia de animales a peletear.");
                    }
                    break;
                default:
                    System.out.println("Si no es peleteo o asignar a familia, entra al default...");
                    res = new HistorialDAO(this.getCon()).put(hist);
            }
        }
        this.desconectar();
        return res;
    }

    private boolean insertarDetalleFamilia(Historial res_historial) {
        res_historial.setDescripcion("Nueva ubicacion: " + res_historial.getAnimal().getUbicacionActual());
        res_historial.setTipo_evento(this.esAsigando());
        boolean res = new HistorialDAO(this.getCon()).put(res_historial);
        if (res != false) {
            boolean res_updateAnimal = new AnimalDAO(this.getCon()).updateAsignar(res_historial.getAnimal());
            if (res_updateAnimal == true) {
                System.out.println("Se pudo insertar en el historial y se hizo el update en el animal");
                return true;
            }
        }
        return false;
    }

    public TipoEvento esDestete() {
        this.conectar();
        System.out.println("Tomando el tipo de evento 'Destete'.");
        TipoEvento even = new TipoEventoDAO(this.getCon()).getTipoEvento("Destete".toUpperCase());
        if (even != null) {
            System.out.println("Datos de tipo de evento encontrado: " + even.getNombre());
        }
        this.desconectar();
        return even;
    }

    private TipoEvento esRalgro() {
        this.conectar();
        System.out.println("Tomando el tipo de evento 'Ralgro'.");
        TipoEvento even = new TipoEventoDAO(this.getCon()).getTipoEvento("Ralgro".toUpperCase());
        this.desconectar();
        return even;
    }

    private TipoEvento esAsigando() {
//        this.conectar();
        System.out.println("Tomando el tipo de evento 'Asignado'.");
        TipoEvento even = new TipoEventoDAO(this.getCon()).getTipoEvento("Asignado".toUpperCase());
//        this.desconectar();
        return even;
    }

    private TipoEvento esPeleteo() {
//        this.conectar();
        System.out.println("Tomando el tipo de evento 'Peleteo'.");
        TipoEvento even = new TipoEventoDAO(this.getCon()).getTipoEvento("Peleteo".toUpperCase());
//        this.desconectar();
        return even;
    }

    private TipoEvento esEnfermedad() {
        this.conectar();
        System.out.println("Tomando el tipo de evento 'Enfermedad'");
        TipoEvento even = new TipoEventoDAO(this.getCon()).getTipoEvento("enfermedad".toUpperCase());
        return even;
    }

//    public void bateriaSeleccionada(Bateria b) {
//        this.bateria = b;
//    }
//
//    public Bateria getBateriaSeleccionada() {
//        return bateria;
//    }
    public Animal getAnimal(String nombreAnimal) {
        this.conectar();
        System.out.println("Buscando animal por su nombre: " + nombreAnimal);
        Animal res = new AnimalDAO(this.getCon()).getAnimal(nombreAnimal);
        this.desconectar();
        return res;
    }

    public Animal getAnimalRalgro(String nombreAnimal) {
        this.conectar();
        System.out.println("Buscando animal por nombre para ralgrear: " + nombreAnimal);
        Animal res = new AnimalDAO(this.getCon()).getAnimalRalgo(nombreAnimal, this.tomarFechaSistema());
        this.desconectar();
        return res;
    }

    public ArrayList<Categoria> allCategorias() {
        //llamada a categoriaDao
        this.conectar();
        System.out.println("Buscando categorias en la base...");
        ArrayList res = new CategoriaDAO(this.getCon()).getCategorias();
//        Categoria cate;
//        Iterator iter = new CategoriaDAO(this.getCon()).getCategorias().iterator();
//        while (iter.hasNext()) {
//            cate = (Categoria) iter.next();
//            res.add(cate);
//        }
//        for (int i = 0; i < 2; i++) {
//            cate = new Categoria();
//            cate.setNombre("Categoria: " + i);
//            res.add(cate);
//        }
        this.desconectar();
        return res;
    }

    public void camaraSeleccionada(Camara camaraRes) {
        camara = camaraRes;
    }

//    public void jaulaSeleccionada(Jaula jaulaRes){
//        this.jaula=jaulaRes;
//    }
    public Camara getCamaraSeleccionada() {
        return this.camara;
    }

    public Jaula getJaulaSeleccionada() {
        return this.jaula;
    }

    public void jaulaSeleccionado(Camara camara) {
        this.animal.setUbicacion(camara);
//        throw new UnsupportedOperationException("Not yet implemented");
//    public void jaulaSeleccionado(Jaula jaula) {
//        Camara camara = cDao.camaraJaula(jaula);
//        this.animal.setUbicacion(camara);
//    }
    }

    public DATE tomarFechaSistema() {
        this.conectar();
        System.out.println("Tomando la fecha desde la base de datos...");
        DATE fecha = new FechaDAO(this.getCon()).tomarFecha();
        if (fecha == null) {
            System.out.println("Error al tomar la fecha del sistema");
            return null;
        } else {
            System.out.println("Fecha tomada de la base de datos: " + String.valueOf(fecha.dateValue()));
        }
        this.desconectar();
        return fecha;
    }

    public void setObservacionVarias(String text) {
        this.observaciones = text;
    }

    private String getObservacionesVarias() {
        return this.observaciones;
    }

    public void jaulaSeleccionada(Jaula jaulaRes, Camara camara) {
        this.camara = camara;
        this.jaula = jaulaRes;
    }

    public ArrayList buscarAnimalesParaPeletear() {
        this.conectar();
        System.out.println("Buscando animales que deben ser destetadas...");
        ArrayList res_destetar = new AnimalDAO(this.getCon()).animalesPeletear(this.tomarFechaSistema());
        String msg;
        if (res_destetar == null || res_destetar.isEmpty() == true) {
            msg = "No hay animales para peletear o se ha detectado un error en la busqueda de los datos.";
        } else {
            msg = "Existen animales para peletear. Hay una cantidad de " + res_destetar.size() + " animales para peletear.";
        }
        System.out.println(msg);
        this.desconectar();
        return res_destetar;
    }

    private boolean aplicarPeleteo() {
        System.out.println("Empezando proceso de peleteo...");
        boolean res = true;
//        this.conectar();
//        Animal res_animal = null;
//        boolean res = true;
//        if (this.getListaPeletear().isEmpty() == false) {
//            Object[] res_animal_peletear = this.getListaPeletear().toArray();
//            for (int i = 0; i < res_animal_peletear.length; i++) {
//                res_animal = (Animal) res_animal_peletear[i];
//                res = true;//new AnimalDAO(this.getCon()).updatePeleteo(res_animal, this.tomarFechaSistema());
//                if (!res) {
//                    System.out.println("Error al procesar el animal " + res_animal.datosAnimal() + ".");
//                    res = false;
//                    break;
//                }
//            }
//        }
//        this.desconectar();
        return res;
    }

    public void setListaPeletear(DefaultListModel res_lista) {
        res_animalesPeletear = res_lista;
    }

    private DefaultListModel getListaPeletear() {
        return res_animalesPeletear;
    }

    public String getHistorial(Animal animal) {
        this.conectar();
        System.out.println("Buscando el historial del animal: " + animal.getNombre());
        String res_historial = new HistorialDAO(this.getCon()).getHistoriales(animal.getNombre());
        this.desconectar();
        return res_historial;
    }

    public ArrayList getHistoriales(Animal animal) {
        this.conectar();
        System.out.println("Buscando los historiales del animal: " + animal.getNombre());
        ArrayList res_historial = new HistorialDAO(this.getCon()).getHistorial(animal.getNombre());
        this.desconectar();
        return res_historial;
    }

    public Sexo esMacho() {
        Sexo macho = this.getSexo('M');
        return macho;
    }

    public Sexo esHembra() {
        Sexo hembra = this.getSexo('H');
        return hembra;
    }

    private Sexo getSexo(char s) {
        this.conectar();
        System.out.println("Tomando el sexo del animal.");
        Sexo sexo = new SexoDAO(this.getCon()).getSexo(new Character(s));
        System.out.println("Sexo tomado: " + sexo.getNombre());
        this.desconectar();
        return sexo;
    }

    public ArrayList buscarMachos() {
        this.buscarEventosFamilia();
        System.out.println("Buscando los machos disponibles para formar una familia.");
        Sexo res_sexo = this.esMacho();
        ArrayList res_machos = this.buscarAnimalesFamilia(res_sexo);
        return res_machos;
    }

    public ArrayList buscarHembras() {
        System.out.println("Buscando las hembras disponibles para formar una familia.");
        Sexo res_sexo = this.esHembra();
        ArrayList res_hembras = this.buscarAnimalesFamilia(res_sexo);
        return res_hembras;
    }

    private ArrayList buscarAnimalesFamilia(Sexo sexo) {
        this.conectar();
        ArrayList res = new HistorialDAO(this.getCon()).getAnimalesFamilia(sexo, this.getE_ralgro(), this.getE_asignado_familia(), this.getE_peleteo());
        this.desconectar();
        return res;
    }

    private void buscarEventosFamilia() {
        System.out.println("Tomando los eventos por el cual el animal no tiene que haber sufrido.");
        this.setE_ralgro(this.esRalgro());
        this.conectar();
        this.setE_asignado_familia(this.esAsigando());
        this.setE_peleteo(this.esPeleteo());
        this.desconectar();
    }

    public TipoEvento getE_asignado_familia() {
        return e_asignado_familia;
    }

    public void setE_asignado_familia(TipoEvento e_asignado_familia) {
        this.e_asignado_familia = e_asignado_familia;
    }

    public TipoEvento getE_peleteo() {
        return e_peleteo;
    }

    public void setE_peleteo(TipoEvento e_peleteo) {
        this.e_peleteo = e_peleteo;
    }

    public TipoEvento getE_ralgro() {
        return e_ralgro;
    }

    public void setE_ralgro(TipoEvento e_ralgro) {
        this.e_ralgro = e_ralgro;
    }

//    private TipoEvento esAsignado() {
//        this.conectar();
//        System.out.println("Tomando el tipo de evento 'ASIGNAR'.");
//        TipoEvento even = new TipoEventoDAO(this.getCon()).getTipoEvento("Asignado".toUpperCase());
//        this.desconectar();
//        return even;
//    }
    private TipoEvento esCuracion() {
        this.conectar();
        System.out.println("Tomando el tipo de evento 'CURACION'");
        TipoEvento evento = new TipoEventoDAO(this.getCon()).getTipoEvento("curacion".toUpperCase());
        this.desconectar();
        return evento;
    }

    public ArrayList buscarNuevaUbicacionFamilia() {
        this.conectar();
        ArrayList res = null;
        int cod_tipoCamara = new TipoCamaraDAO(this.getCon()).devolverCodigoCamara("reproduccion".toUpperCase());
        int cod_estado = new EstadoJaulaDAO(this.getCon()).devolverCodigoEstadoJaula("libre".toUpperCase());
        res = new JaulaDAO(this.getCon()).getJaulas(cod_tipoCamara, cod_estado);
        if (res != null && res.isEmpty() == false) {
            this.codigo_bateria = new JaulaDAO(this.getCon()).getBateriaDisponible();
            System.out.println("Codigo de bateria encontrado en buscarNuevaUbicacionFamilia: " + this.codigo_bateria);
        }
        this.desconectar();
        return res;
    }

    public Bateria getBateriaNuevaUbicacion() {
        this.conectar();
        int cod = this.codigo_bateria;
        System.out.println("Codigo de bateria en getBateriaNuevaUbicacion: " + cod);
        Bateria res = new BateriaDAO(this.getCon()).getBateria(cod);
        this.desconectar();
        return res;
    }

    public ArrayList getHistoriales(int evento, int dias) {
        this.conectar();
        String nom_evento = null;
        switch (evento) {
            case TipoEvento.NACIMIENTO:
                nom_evento = "nacimiento".toUpperCase();
                break;
            case TipoEvento.MUERTE:
                nom_evento = "muerte".toUpperCase();
                break;
            case TipoEvento.PELETEO:
                nom_evento = "peleteo".toUpperCase();
                break;
            case TipoEvento.ENFERMEDAD:
                nom_evento = "enfermedad".toUpperCase();
                break;
            case TipoEvento.DESTETE:
                nom_evento = "destete".toUpperCase();
                break;
            case TipoEvento.ASIGNAR:
                nom_evento = "asignado".toUpperCase();
                break;
            case TipoEvento.RALGRO:
                nom_evento = "ralgro".toUpperCase();
                break;
            case TipoEvento.CURACION:
                nom_evento = "curacion".toUpperCase();
                break;
        }
        TipoEvento tp = new TipoEvento(nom_evento, null);
        System.out.println("Tipo de evento seleccionado: " + tp.getNombre());
        int tipo_evento = new TipoEventoDAO(this.getCon()).getCodigoTipoEvento(tp);
        ArrayList res_historial = new HistorialDAO(this.getCon()).getHistorialEvento(tipo_evento, dias);
        this.desconectar();
        return res_historial;
    }

    private boolean asignarFamilia() {
        System.out.println("Asignando animales a nueva familia.");
        return true;
    }

    public void setListaFamilia(ArrayList res_animalesAsignados) {
        res_animalesFamilia = res_animalesAsignados;
    }

    public ArrayList getListaFamilia() {
        return res_animalesFamilia;
    }

    public void setFamilia(Familia res_familia) {
        this.familia = res_familia;
    }

    public Familia getFamilia() {
        return familia;
    }

    public ArrayList getPlanActividades(int destete, int peleteo, int ralgro) {
        System.out.println("hacer el metodo para devolver el arra con el plan de actividades");
        this.conectar();
        ArrayList res_actividades = new HistorialDAO(this.getCon()).getActividades(destete, peleteo, ralgro, this.tomarFechaSistema());
        this.desconectar();
        return res_actividades;
    }

    public boolean actividadesDia() {
        this.conectar();
        boolean res = new HistorialDAO(this.getCon()).hayActividades(this.tomarFechaSistema());
        this.desconectar();
        return res;
    }

    public ArrayList allEnfermedad() {
        this.conectar();
        ArrayList res = new EnfermedadDAO(this.getCon()).getEnfermedades();
        this.desconectar();
        return res;
    }

    private boolean asignarEnfermedad() {
        System.out.println("Registrando enfermedad en animal.");
        return true;
    }

    public void setEnfermedad(Enfermedad enfermedad) {
        this.enfermedad = enfermedad;
    }

    public Enfermedad getEnfermedadAnimal() {
        return enfermedad;
    }

    public Enfermedad buscarEnfermedad(Animal animal) {
        System.out.println("Buscando la enfermedad para el animal: " + animal.getNombre());
        this.conectar();
        Enfermedad res = new EnfermedadDAO(this.getCon()).getEnfermedadAnimal(animal.getNombre());
        this.desconectar();
        return res;
    }
//            this.conectar();
//        System.out.println("Buscando animales a destetar...");
//        ArrayList paraDestete = new AnimalDAO(this.getCon()).animalesDestetar(this.tomarFechaSistema());
//        if (paraDestete == null || paraDestete.isEmpty() == true) {
//            System.out.println("No hay animales a destetar o se ha detectato un error en la busqueda de datos...");
//            return null;
//        } else {
//            System.out.println("Existen animales para destetar. Hay una cantidad de " + paraDestete.size() + " gazapos.");
//        }
//        this.desconectar();
//        return paraDestete;
}
//}

